

#ifndef STORAGEDAO_STRUCT_H
#define STORAGEDAO_STRUCT_H

#include <stdint.h>
#include <string>
#include <iostream>
#include "libc2c/byte_stream.h"
#include "app_platform/intf_service_object.h"
#include "erp/storage/ddo/overflowbillddo_storage.h"	
#include "erp/storage/ddo/disassemblebillfilterddo_storage.h"	
#include <set>	
#include <map>	
#include <vector>	
#include "erp/storage/ddo/stockddo_storage.h"	
#include "erp/storage/ddo/stockcheckitemddo_storage.h"	
#include "erp/storage/ddo/stockcheckfilterddo_storage.h"	
#include "erp/storage/ddo/disassemblebillddo_storage.h"	
#include "erp/storage/ddo/losebillddo_storage.h"	
#include "erp/storage/ddo/stockcheckmasterddo_storage.h"	
#include "erp/storage/ddo/overflowbillorlosebillfilterddo_storage.h"	
#include "erp/storage/ddo/stockfilterddo_storage.h"	
#include "erp/storage/ddo/stockbranch_relddo_storage.h"	

namespace erp
{
namespace storage
{
namespace dao
{

	const uint32_t STORAGEDAO_ADDDISASSEMBLEBILL_REQ_CMD_ID = 0xc05e1813; /// 请求命令号
	const uint32_t STORAGEDAO_ADDDISASSEMBLEBILL_RESP_CMD_ID = 0xc05e8813; /// 回应命令号
	

	const uint32_t STORAGEDAO_ADDLOSEBILLOROVERFLOWBILL_REQ_CMD_ID = 0xc05e1808; /// 请求命令号
	const uint32_t STORAGEDAO_ADDLOSEBILLOROVERFLOWBILL_RESP_CMD_ID = 0xc05e8808; /// 回应命令号
	

	const uint32_t STORAGEDAO_ADDSTOCK_REQ_CMD_ID = 0xc05e1801; /// 请求命令号
	const uint32_t STORAGEDAO_ADDSTOCK_RESP_CMD_ID = 0xc05e8801; /// 回应命令号
	

	const uint32_t STORAGEDAO_ADDSTOCKCHECK_REQ_CMD_ID = 0xc05e1818; /// 请求命令号
	const uint32_t STORAGEDAO_ADDSTOCKCHECK_RESP_CMD_ID = 0xc05e8818; /// 回应命令号
	

	const uint32_t STORAGEDAO_DELETEDISASSEMBLEBILL_REQ_CMD_ID = 0xc05e1814; /// 请求命令号
	const uint32_t STORAGEDAO_DELETEDISASSEMBLEBILL_RESP_CMD_ID = 0xc05e8814; /// 回应命令号
	

	const uint32_t STORAGEDAO_DELETELOSEBILLOROVERFLOWBILL_REQ_CMD_ID = 0xc05e1809; /// 请求命令号
	const uint32_t STORAGEDAO_DELETELOSEBILLOROVERFLOWBILL_RESP_CMD_ID = 0xc05e8809; /// 回应命令号
	

	const uint32_t STORAGEDAO_DELETESTOCK_REQ_CMD_ID = 0xc05e1802; /// 请求命令号
	const uint32_t STORAGEDAO_DELETESTOCK_RESP_CMD_ID = 0xc05e8802; /// 回应命令号
	

	const uint32_t STORAGEDAO_DELETESTOCKCHECK_REQ_CMD_ID = 0xc05e1819; /// 请求命令号
	const uint32_t STORAGEDAO_DELETESTOCKCHECK_RESP_CMD_ID = 0xc05e8819; /// 回应命令号
	

	const uint32_t STORAGEDAO_GETDISASSEMBLEBILLBYSYSNOS_REQ_CMD_ID = 0xc05e1816; /// 请求命令号
	const uint32_t STORAGEDAO_GETDISASSEMBLEBILLBYSYSNOS_RESP_CMD_ID = 0xc05e8816; /// 回应命令号
	

	const uint32_t STORAGEDAO_GETDISASSEMBLEBILLLIST_REQ_CMD_ID = 0xc05e1817; /// 请求命令号
	const uint32_t STORAGEDAO_GETDISASSEMBLEBILLLIST_RESP_CMD_ID = 0xc05e8817; /// 回应命令号
	

	const uint32_t STORAGEDAO_GETLOSEBILLOROVERFLOWBILLBYSYSNOS_REQ_CMD_ID = 0xc05e1811; /// 请求命令号
	const uint32_t STORAGEDAO_GETLOSEBILLOROVERFLOWBILLBYSYSNOS_RESP_CMD_ID = 0xc05e8811; /// 回应命令号
	

	const uint32_t STORAGEDAO_GETLOSEBILLOROVERFLOWBILLLIST_REQ_CMD_ID = 0xc05e1812; /// 请求命令号
	const uint32_t STORAGEDAO_GETLOSEBILLOROVERFLOWBILLLIST_RESP_CMD_ID = 0xc05e8812; /// 回应命令号
	

	const uint32_t STORAGEDAO_GETSTOCKBRANCH_RELBYSYSNO_REQ_CMD_ID = 0xc05e1807; /// 请求命令号
	const uint32_t STORAGEDAO_GETSTOCKBRANCH_RELBYSYSNO_RESP_CMD_ID = 0xc05e8807; /// 回应命令号
	

	const uint32_t STORAGEDAO_GETSTOCKBYSYSNOS_REQ_CMD_ID = 0xc05e1804; /// 请求命令号
	const uint32_t STORAGEDAO_GETSTOCKBYSYSNOS_RESP_CMD_ID = 0xc05e8804; /// 回应命令号
	

	const uint32_t STORAGEDAO_GETSTOCKCHECKBYSYSNOS_REQ_CMD_ID = 0xc05e1821; /// 请求命令号
	const uint32_t STORAGEDAO_GETSTOCKCHECKBYSYSNOS_RESP_CMD_ID = 0xc05e8821; /// 回应命令号
	

	const uint32_t STORAGEDAO_GETSTOCKCHECKLIST_REQ_CMD_ID = 0xc05e1822; /// 请求命令号
	const uint32_t STORAGEDAO_GETSTOCKCHECKLIST_RESP_CMD_ID = 0xc05e8822; /// 回应命令号
	

	const uint32_t STORAGEDAO_GETSTOCKLIST_REQ_CMD_ID = 0xc05e1805; /// 请求命令号
	const uint32_t STORAGEDAO_GETSTOCKLIST_RESP_CMD_ID = 0xc05e8805; /// 回应命令号
	

	const uint32_t STORAGEDAO_MODIFYSTOCKBRANCH_REL_REQ_CMD_ID = 0xc05e1806; /// 请求命令号
	const uint32_t STORAGEDAO_MODIFYSTOCKBRANCH_REL_RESP_CMD_ID = 0xc05e8806; /// 回应命令号
	

	const uint32_t STORAGEDAO_UPDATADISASSEMBLEBILL_REQ_CMD_ID = 0xc05e1815; /// 请求命令号
	const uint32_t STORAGEDAO_UPDATADISASSEMBLEBILL_RESP_CMD_ID = 0xc05e8815; /// 回应命令号
	

	const uint32_t STORAGEDAO_UPDATALOSEBILLOROVERFLOWBILL_REQ_CMD_ID = 0xc05e1810; /// 请求命令号
	const uint32_t STORAGEDAO_UPDATALOSEBILLOROVERFLOWBILL_RESP_CMD_ID = 0xc05e8810; /// 回应命令号
	

	const uint32_t STORAGEDAO_UPDATASTOCKCHECK_REQ_CMD_ID = 0xc05e1820; /// 请求命令号
	const uint32_t STORAGEDAO_UPDATASTOCKCHECK_RESP_CMD_ID = 0xc05e8820; /// 回应命令号
	

	const uint32_t STORAGEDAO_UPDATESTOCK_REQ_CMD_ID = 0xc05e1803; /// 请求命令号
	const uint32_t STORAGEDAO_UPDATESTOCK_RESP_CMD_ID = 0xc05e8803; /// 回应命令号
	


const uint16_t STORAGEDAO_MAX_PROTOCAL_VERSION = 2; //>平台支持的最大协议版本号


///////////////////////////// STRUCTS /////////////////////////////////////////////////
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoAddDisassembleBillReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		erp::storage::ddo::CDisassembleBillDdo DisassembleBillInfo;	
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		uint64_t DisassembleBillSysNo;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_ADDDISASSEMBLEBILL_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			DisassembleBillInfo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoAddDisassembleBillResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
		uint64_t DisassembleBillSysNo;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_ADDDISASSEMBLEBILL_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
			bs & DisassembleBillSysNo;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoAddLoseBillOrOverFlowBillReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		erp::storage::ddo::CLoseBillDdo LoseBillInfo;	
		erp::storage::ddo::COverFlowBillDdo OverFlowBillInfo;	
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		uint64_t OverFlowBillSysNo;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_ADDLOSEBILLOROVERFLOWBILL_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			LoseBillInfo.Serialize(bs);
			OverFlowBillInfo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoAddLoseBillOrOverFlowBillResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
		uint64_t OverFlowBillSysNo;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_ADDLOSEBILLOROVERFLOWBILL_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
			bs & OverFlowBillSysNo;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoAddStockReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		erp::storage::ddo::CStockDdo StockInfo;	
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		uint64_t StockSysNo;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_ADDSTOCK_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			StockInfo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoAddStockResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
		uint64_t StockSysNo;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_ADDSTOCK_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
			bs & StockSysNo;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoAddStockCheckReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		erp::storage::ddo::CStockCheckMasterDdo StockCheckMasterInfo;	
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		uint64_t StockCheckMasterSysNo;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_ADDSTOCKCHECK_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			StockCheckMasterInfo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoAddStockCheckResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
		uint64_t StockCheckMasterSysNo;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_ADDSTOCKCHECK_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
			bs & StockCheckMasterSysNo;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoDeleteDisassembleBillReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		std::set<uint64_t > DisassemblebillSysNos;
		std::string inReserve;
		std::string errmsg;
		std::map<uint64_t,uint32_t > errorCode;
		std::map<uint64_t,std::string > errorMsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_DELETEDISASSEMBLEBILL_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			bs & DisassemblebillSysNos;
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoDeleteDisassembleBillResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::map<uint64_t,uint32_t > errorCode;
		std::map<uint64_t,std::string > errorMsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_DELETEDISASSEMBLEBILL_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & errorCode;
			bs & errorMsg;
			bs & outReserve;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoDeleteLoseBillOrOverFlowBillReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		std::set<uint64_t > FLoseBillSysNo;
		std::set<uint64_t > FOverFlowBillSysNo;
		std::string inReserve;
		std::string errmsg;
		std::map<uint64_t,uint32_t > errorCode;
		std::map<uint64_t,std::string > errorMsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_DELETELOSEBILLOROVERFLOWBILL_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			bs & FLoseBillSysNo;
			bs & FOverFlowBillSysNo;
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoDeleteLoseBillOrOverFlowBillResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::map<uint64_t,uint32_t > errorCode;
		std::map<uint64_t,std::string > errorMsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_DELETELOSEBILLOROVERFLOWBILL_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & errorCode;
			bs & errorMsg;
			bs & outReserve;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoDeleteStockReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		std::set<uint64_t > FStockSysNo;
		std::string inReserve;
		std::string errmsg;
		std::map<uint64_t,uint32_t > errorCode;
		std::map<uint64_t,std::string > errorMsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_DELETESTOCK_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			bs & FStockSysNo;
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoDeleteStockResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::map<uint64_t,uint32_t > errorCode;
		std::map<uint64_t,std::string > errorMsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_DELETESTOCK_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & errorCode;
			bs & errorMsg;
			bs & outReserve;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoDeleteStockCheckReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		std::set<uint64_t > StockCheckMasterSysNos;
		std::string inReserve;
		std::string errmsg;
		std::map<uint64_t,uint32_t > errorCode;
		std::map<uint64_t,std::string > errorMsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_DELETESTOCKCHECK_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			bs & StockCheckMasterSysNos;
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoDeleteStockCheckResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::map<uint64_t,uint32_t > errorCode;
		std::map<uint64_t,std::string > errorMsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_DELETESTOCKCHECK_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & errorCode;
			bs & errorMsg;
			bs & outReserve;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoGetDisassembleBillBySysNosReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		std::set<uint64_t > DisassembleBillSysnoList;
		std::string inReserve;
		std::string errmsg;
		std::vector<erp::storage::ddo::CDisassembleBillDdo > DisassembleBillList;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETDISASSEMBLEBILLBYSYSNOS_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & DisassembleBillSysnoList;
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoGetDisassembleBillBySysNosResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::vector<erp::storage::ddo::CDisassembleBillDdo > DisassembleBillList;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETDISASSEMBLEBILLBYSYSNOS_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & DisassembleBillList;
			bs & outReserve;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoGetDisassembleBillListReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		erp::storage::ddo::CDisassembleBillFilterDdo DisassembleBillFilter;	
		std::string inReserve;
		std::string errmsg;
		uint32_t total;
		std::vector<erp::storage::ddo::CDisassembleBillDdo > DisassembleBillList;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETDISASSEMBLEBILLLIST_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			DisassembleBillFilter.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoGetDisassembleBillListResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		uint32_t total;
		std::vector<erp::storage::ddo::CDisassembleBillDdo > DisassembleBillList;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETDISASSEMBLEBILLLIST_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & total;
			bs & DisassembleBillList;
			bs & outReserve;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoGetLoseBillOrOverFlowBillBySysNosReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		std::set<uint64_t > LoseBillSysNoList;
		std::set<uint64_t > OverFlowSysNoList;
		std::string inReserve;
		std::string errmsg;
		std::vector<erp::storage::ddo::CLoseBillDdo > LoseBillList;
		std::vector<erp::storage::ddo::COverFlowBillDdo > OverFlowList;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETLOSEBILLOROVERFLOWBILLBYSYSNOS_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & LoseBillSysNoList;
			bs & OverFlowSysNoList;
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoGetLoseBillOrOverFlowBillBySysNosResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::vector<erp::storage::ddo::CLoseBillDdo > LoseBillList;
		std::vector<erp::storage::ddo::COverFlowBillDdo > OverFlowList;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETLOSEBILLOROVERFLOWBILLBYSYSNOS_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & LoseBillList;
			bs & OverFlowList;
			bs & outReserve;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoGetLoseBillOrOverFlowBillListReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		erp::storage::ddo::COverFlowBillOrLoseBillFilterDdo OverFlowBillOrLoseBillFilter;	
		std::string inReserve;
		std::string errmsg;
		uint32_t total;
		std::vector<erp::storage::ddo::CLoseBillDdo > LoseBillList;
		std::vector<erp::storage::ddo::COverFlowBillDdo > OverFlowList;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETLOSEBILLOROVERFLOWBILLLIST_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			OverFlowBillOrLoseBillFilter.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoGetLoseBillOrOverFlowBillListResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		uint32_t total;
		std::vector<erp::storage::ddo::CLoseBillDdo > LoseBillList;
		std::vector<erp::storage::ddo::COverFlowBillDdo > OverFlowList;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETLOSEBILLOROVERFLOWBILLLIST_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & total;
			bs & LoseBillList;
			bs & OverFlowList;
			bs & outReserve;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoGetStockBranch_RelBySysNoReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		uint64_t StockSysNo;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		std::vector<erp::storage::ddo::CStockBranch_RelDdo > StockBranchList;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETSTOCKBRANCH_RELBYSYSNO_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			bs & StockSysNo;
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoGetStockBranch_RelBySysNoResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
		std::vector<erp::storage::ddo::CStockBranch_RelDdo > StockBranchList;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETSTOCKBRANCH_RELBYSYSNO_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
			bs & StockBranchList;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoGetStockBySysNosReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		std::set<uint64_t > StockSysnoList;
		std::string inReserve;
		std::string errmsg;
		std::vector<erp::storage::ddo::CStockDdo > StockList;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETSTOCKBYSYSNOS_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & StockSysnoList;
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoGetStockBySysNosResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::vector<erp::storage::ddo::CStockDdo > StockList;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETSTOCKBYSYSNOS_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & StockList;
			bs & outReserve;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoGetStockCheckBySysNosReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		std::set<uint64_t > StockCheckMasterSysNoList;
		std::string inReserve;
		std::string errmsg;
		std::vector<erp::storage::ddo::CStockCheckMasterDdo > StockCheckList;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETSTOCKCHECKBYSYSNOS_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & StockCheckMasterSysNoList;
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoGetStockCheckBySysNosResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::vector<erp::storage::ddo::CStockCheckMasterDdo > StockCheckList;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETSTOCKCHECKBYSYSNOS_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & StockCheckList;
			bs & outReserve;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoGetStockCheckListReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		erp::storage::ddo::CStockCheckFilterDdo StockCheckFilter;	
		std::string inReserve;
		std::string errmsg;
		uint32_t total;
		std::vector<erp::storage::ddo::CStockCheckMasterDdo > StockCheckList;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETSTOCKCHECKLIST_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			StockCheckFilter.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoGetStockCheckListResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		uint32_t total;
		std::vector<erp::storage::ddo::CStockCheckMasterDdo > StockCheckList;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETSTOCKCHECKLIST_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & total;
			bs & StockCheckList;
			bs & outReserve;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoGetStockListReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		erp::storage::ddo::CStockFilterDdo StockFilter;	
		std::string inReserve;
		std::string errmsg;
		uint32_t total;
		std::vector<erp::storage::ddo::CStockDdo > StockList;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETSTOCKLIST_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			StockFilter.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoGetStockListResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		uint32_t total;
		std::vector<erp::storage::ddo::CStockDdo > StockList;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETSTOCKLIST_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & total;
			bs & StockList;
			bs & outReserve;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoModifyStockBranch_RelReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		uint64_t StockSysNo;
		std::set<uint64_t > BranchSysNos;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_MODIFYSTOCKBRANCH_REL_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			bs & StockSysNo;
			bs & BranchSysNos;
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoModifyStockBranch_RelResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_MODIFYSTOCKBRANCH_REL_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoUpdataDisassembleBillReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		erp::storage::ddo::CDisassembleBillDdo DisassembleBillInfo;	
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_UPDATADISASSEMBLEBILL_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			DisassembleBillInfo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoUpdataDisassembleBillResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_UPDATADISASSEMBLEBILL_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoUpdataLoseBillOrOverFlowBillReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		erp::storage::ddo::CLoseBillDdo LoseBillInfo;	
		erp::storage::ddo::COverFlowBillDdo OverFlowBillInfo;	
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_UPDATALOSEBILLOROVERFLOWBILL_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			LoseBillInfo.Serialize(bs);
			OverFlowBillInfo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoUpdataLoseBillOrOverFlowBillResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_UPDATALOSEBILLOROVERFLOWBILL_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoUpdataStockCheckReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		erp::storage::ddo::CStockCheckMasterDdo StockCheckMasterInfo;	
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_UPDATASTOCKCHECK_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			StockCheckMasterInfo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoUpdataStockCheckResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_UPDATASTOCKCHECK_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoUpdateStockReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		erp::storage::ddo::CStockDdo StockInfo;	
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_UPDATESTOCK_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //    return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			StockInfo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
		
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CStorageDaoUpdateStockResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_UPDATESTOCK_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;

		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};	

}
}
}

#endif /* STORAGEDAO_STRUCT_H */

